package com.shareach.dao.redis.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.shareach.domain.DiscountType;
import com.shareach.redis.RedisService;

/**
 * @author apple
 * 
 */
@Repository
public class MatchRDao {
	/**
	 * 一天的时间间隔
	 */
	private static int DayTimeLong = 24 * 60 * 60 ;// 暂时设置一个星期
	@Autowired
	private RedisService redisService;
	/**
	 * 新增加的商户全部添加到此列表 SortedSet，第一个参数是 类型：tuan/tkt/bnk/act
	 * value是对应类型的优惠商户表id,Score是时间，新添加的score是0
	 */
	private static final String Match_Shop_Un = "match:un:%s";

	/**
	 * 匹配成功移动到此队列中 SortedSet，第一个参数是 类型：tuan/tkt/bnk/act,外加一个微博
	 * value是对应类型的优惠商户表id,Score是时间，新添加的score是0
	 */
	private static final String Match_Shop_Succ = "match:suc:%s";
	/**
	 * 已经找到目标网站的Id，正在采集的商户列表，如果采集失败一天后再采集 SortedSet，第一个参数是 Site
	 * value是对应网站的Id，Score是采集时间，新添加的score是0
	 */
	private static final String Match_Shop_Snatch = "match:sna:%s";

	/**
	 * 新增加的商户全部添加到此列表
	 * 
	 * @param type
	 * @param id
	 *            指定类型的优惠商户Id
	 */
	public void addDiscountShop(DiscountType type, long id) {
		String key = String.format(Match_Shop_Un, type.getCode());
		String sId = String.valueOf(id);
		if (!redisService.getRedis().isContainsSortedSet(key, sId))
			redisService.getRedis().addSortedSet(key, sId, 0);
	}

	/**
	 * 匹配完成时，设置Score为当前时间，表示未匹配上
	 * 
	 * @param type
	 * @param id
	 */
	public void setDiscountShopUnmap(DiscountType type, long id) {
		String key = String.format(Match_Shop_Un, type.getCode());
		String sId = String.valueOf(id);
		if (redisService.getRedis().isContainsSortedSet(key, sId))
			redisService.getRedis().addSortedSet(key, sId);
	}

	/**
	 * 将匹配过但是未匹配上的商户充值到未批队列
	 * 
	 * @param type
	 * @return
	 */
	public void setRemap(DiscountType type) {
		String key = String.format(Match_Shop_Un, type.getCode());
		Set<String> set = redisService.getRedis().getSetScores(key, 1000000, ((new Date()).getTime() + DayTimeLong * 1000),100);
		while(set!=null && !set.isEmpty()){
			Map<Double, String> map = new HashMap<Double, String>();
			for (String s : set) {
				map.put(100d, s);
			}
			redisService.getRedis().addSortedSet(key, map);
			set = redisService.getRedis().getSetScores(key, 1000000, ((new Date()).getTime() + DayTimeLong * 1000),100);
		}
	}
	/**
	 * 获取指定数量的未匹配的商户信息 默认取未匹配和DayTimeLong以前的未匹配成功的商户
	 * 
	 * @param type
	 * @return
	 */
	public List<Long> getUnmapList(DiscountType type) {
		String key = String.format(Match_Shop_Un, type.getCode());
		Set<String> set = redisService.getRedis().getSetScores(key, 0, ((new Date()).getTime() - DayTimeLong * 1000),
				100);
		List<Long> results = new ArrayList<Long>();
		if (set != null) {
			for (String s : set) {
				results.add(Long.parseLong(s));
			}
		}
		return results;
	}

	/**
	 * 获取所有未匹配成功队列数据重新设置其score
	 * zuoshuai
	 * @param type
	 * @return
	 */
	public List<Long> resetUmMapList(DiscountType type) {
		String key = String.format(Match_Shop_Un, type.getCode());
		Set<String> set = redisService.getRedis().getSetScores(key, 1, (new Date()).getTime(), 1000);
		List<Long> results = new ArrayList<Long>();
		if (set != null) {
			for (String s : set) {
				redisService.getRedis().addSortedSet(key, s, 0);
			}
		}
		return results;
	}
	

	/**
	 * 重新将指定Id换为未匹配状态，也就是从成功队列中移除，放入未匹配队列
	 * 【注】慎用，所以用过期表示
	 * 仅当重置的时候使用
	 * @param type
	 * @param id
	 */
	@Deprecated  
	public void resetDiscountUnmap(DiscountType type, long id) {
		String sId = String.valueOf(id);
		//从匹配成功中移除
		redisService.getRedis().removeSortedSet(String.format(Match_Shop_Succ,type.getCode()), sId);
		//添加到未匹配
		redisService.getRedis().addSortedSet(String.format(Match_Shop_Un, type.getCode()), sId,0);
	}
	
	/**
	 * 如果匹配队列和未匹配队列中不存在，则添加
	 * 主要用于添加异常导致的数据遗漏
	 * @param type
	 * @param id
	 */
	public void addDiscountUnmap(DiscountType type, long id) {
		String sId = String.valueOf(id);
		//是否在成功队列
		if(redisService.getRedis().isContainsSortedSet(String.format(Match_Shop_Succ,type.getCode()), sId)) return;
		//是否在匹配
		if(redisService.getRedis().isContainsSortedSet(String.format(Match_Shop_Un, type.getCode()), sId)) return;
		//添加到未匹配
		redisService.getRedis().addSortedSet(String.format(Match_Shop_Un, type.getCode()), sId,0);
	}
	
	
	

	/**
	 * 匹配成功将指定商户从未匹配列表中移除
	 * 
	 * @param type
	 * @param id
	 */
	public void removeDiscountShopUnmap(DiscountType type, long id) {
		String sId = String.valueOf(id);
		//添加到匹配成功
		redisService.getRedis().addSortedSet(String.format(Match_Shop_Succ,type.getCode()), sId);
		//从未匹配移除
		redisService.getRedis().removeSortedSet(String.format(Match_Shop_Un, type.getCode()), sId);
	}

	/**
	 * 设置需要从指定网站去采集商户信息的
	 * 
	 * @param site
	 * @param siteId
	 * @param id
	 */
	public void setSnatchShop(String site, String siteId) {
		String key = String.format(Match_Shop_Snatch, site);
		if (!redisService.getRedis().isContainsSortedSet(key, siteId))
			redisService.getRedis().addSortedSet(key, siteId, 0);
	}

	/**
	 * 当商户信息采集下来了，则移除
	 * 
	 * @param site
	 * @param siteId
	 */
	public void removeSnatchShop(String site, String siteId) {
		String key = String.format(Match_Shop_Snatch, site);
		redisService.getRedis().removeSortedSet(key, siteId);
	}
	/**
	 * 删除指定类型的队列
	 * @param type
	 * @param siteId
	 */
	public void removeRedis(DiscountType type,String siteId){
		redisService.getRedis().removeSortedSet(String.format(Match_Shop_Un, type.getCode()), siteId);
		redisService.getRedis().removeSortedSet(String.format(Match_Shop_Succ, type.getCode()),siteId);
	}

}
